﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.ComponentModel;
using System.Text;
//librerias especiales para la BD
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Data.SqlTypes;

namespace CityGames
{
    public class CADTorneo
    {
        static private string cadConexion = System.Configuration.ConfigurationManager.ConnectionStrings["CityGames.Properties.Settings.BDCityGamesConnectionString"].ConnectionString;
        static private DSTorneosTableAdapters.SociosDeGrupoTA sociosDeGrupoTA = new DSTorneosTableAdapters.SociosDeGrupoTA();
        static private DSTorneosTableAdapters.EventosTA eventosTA = new DSTorneosTableAdapters.EventosTA();
        static private CADPartidoPlayoff cadPartido = new CADPartidoPlayoff();


        /************************************************** Funciones de Marcos **************************************************/

        /// <summary>
        /// Función que ejecuta la consulta pasada por parámetro en Modo Desconectado y devuelve un DataSet con el resultado en una tabla denominada con el nombre especificado
        /// </summary>
        /// <param name="select">
        /// Sentencia Select SQL que se va a ejecutar</param>
        /// <param name="nombreTabla">
        /// Nombre que tendrá la tabla con los datos en el DataSet que devuelve la función</param>
        /// <returns>
        /// Devuelve un DataSet con el resultado de la consulta ejecutado en modo desconectado</returns>
        public DataSet ObtenerDatos(string select, string nombreTabla)
        {
            DataSet resultado = new DataSet();

            try
            {
                SqlConnection conexion = new SqlConnection(cadConexion);
                SqlDataAdapter da = new SqlDataAdapter(select, conexion);
                da.Fill(resultado, nombreTabla);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para actualizar la Base de Datos con las modificaciones realizadas sobre el DataSet pasado por parámetro.
        /// </summary>
        /// <param name="datosModificados">
        /// DataSet con los cambios que se desean aplicar a la Base de Datos</param>
        /// <param name="select">
        /// Sentencia SQL Select original con la que se rellenó el DataSet</param>
        /// <returns>Devuelve True si todo ha ido bien, False en caso contrario</returns>
        public bool InsertarDatosModificados(DataSet datosModificados, string select)
        {
            bool resultado = false;

            try
            {
                SqlConnection conexion = new SqlConnection(cadConexion);
                SqlDataAdapter da = new SqlDataAdapter(select, conexion);
                SqlCommandBuilder cb = new SqlCommandBuilder(da);
                da.Update(datosModificados, datosModificados.Tables[0].TableName);

                resultado = true;
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los datos de los partidos de un grupo de un torneo
        /// </summary>
        /// <param name="nombreEvento">
        /// Nombre del torneo del cual se desean obtener los Partidos de un grupo en específico</param>
        /// <param name="letraGrupo">
        /// Letra del grupo del cual se desean obtener los partidos (A, B, C ó D)</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "Partidos" en donde se encuentran todos los partidos del grupo del evento especificado</returns>
        public DataSet ObtenerPartidosDeGrupo(string nombreEvento, string letraGrupo)
        {
            DataSet partidos = new DataSet();
            string select = "";

            try
            {
                select += "SELECT NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB, PuntosA, PuntosB ";
                select += "FROM PartidoGrupo ";
                select += "WHERE (NombreEvento = '" + nombreEvento + "') AND (LetraGrupo = '" + letraGrupo + "') ";
                select += "ORDER BY Partido ASC";

                partidos = ObtenerDatos(select, "Partidos");
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return partidos;
        }

        /// <summary>
        /// Función para guardar en modo desconectado las modificaciones realizadas sobre los partidos de un grupo de un torneo
        /// </summary>
        /// <param name="partidos">
        /// DataSet que contiene los datos de los partidos ya modificados cuyos cambios se desean reflejar en la Base de Datos</param>
        /// <param name="nombreEvento">
        /// Nombre del torneo al cual pertenecen los partidos</param>
        /// <param name="letraGrupo">
        /// Letra del grupo al cual pertenecen los partidos (A, B, C ó D)</param>
        /// <returns>
        /// Devuelve True en caso de que no se haya producido ningún error en la actualización de la Base de Datos, False en caso contrario</returns>
        public bool GuardarPartidosDeGrupo(DataSet partidos, string nombreEvento, string letraGrupo)
        {
            bool resultado = false;
            string select = "";

            try
            {
                select += "SELECT NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB, PuntosA, PuntosB ";
                select += "FROM PartidoGrupo ";
                select += "WHERE (NombreEvento = '" + nombreEvento + "') AND (LetraGrupo = '" + letraGrupo + "') ";
                select += "ORDER BY Partido ASC";

                resultado = InsertarDatosModificados(partidos, select);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los datos de los socios pertenecientes a un grupo de un torneo
        /// </summary>
        /// <param name="nombreEvento">
        /// Nombre del torneo del cual se desean obtener los datos de los socios que pertenecen a uno de sus grupos</param>
        /// <param name="letraGrupo">
        /// Grupo del cual se desean obtener los datos de los socios (A, B, C ó D)</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "SociosDeGrupo" con los datos de los socios pertenecientes al grupo del torneo especificado</returns>
        public DataSet ObtenerSociosDeGrupo(string nombreEvento, string letraGrupo)
        {
            DataSet socios = new DataSet();
            string select = "";

            try
            {
                select += "SELECT Nombre, Apellidos, Puntos, PuntosAFavor AS 'A Favor', PuntosEnContra AS 'En Contra', DNISocio ";
                select += "FROM SocioDeGrupo, Persona ";
                select += "WHERE (NombreEvento = '" + nombreEvento + "') AND (LetraGrupo = '" + letraGrupo + "') AND (SocioDeGrupo.DNISocio = Persona.DNI) ";
                select += "ORDER BY Apellidos ASC";

                socios = ObtenerDatos(select, "SociosDeGrupo");
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return socios;
        }

        /// <summary>
        /// Función para comprobar si existe un grupo determinado de un torneo
        /// </summary>
        /// <param name="nombreEvento">
        /// Nombre del torneo del cual se desea comprobar si existe el grupo</param>
        /// <param name="letraGrupo">
        /// Grupo que se desea comprobar su existencia en el torneo (A, B, C ó D)</param>
        /// <returns>
        /// Devuelve True en caso de que exista el grupo en el torneo, False en caso contrario</returns>
        public bool ExisteGrupo(string nombreEvento, string letraGrupo)
        {
            bool resultado = false;
            SqlConnection conexion = null;

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();
                
                string select = "SELECT * FROM Grupo WHERE (NombreEvento = @nombreEvento) AND (LetraGrupo = @letraGrupo)";
                
                SqlCommand comandoSql = new SqlCommand(select, conexion);
                comandoSql.Parameters.Add("@nombreEvento", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreEvento"].Value = nombreEvento;
                comandoSql.Parameters.Add("@letraGrupo", SqlDbType.VarChar, 1);
                comandoSql.Parameters["@letraGrupo"].Value = letraGrupo;
                SqlDataReader dr = comandoSql.ExecuteReader();

                if (dr.Read())
                    resultado = true;
                else
                    resultado = false;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para actualizar los puntos de un socio utilizando el elemento del proyecto DataSet (TableAdapter)
        /// </summary>
        /// <param name="nombreEvento">
        /// Nombre del evento al que pertenece el socio</param>
        /// <param name="letraGrupo">
        /// Letra del grupo al que pertenece el socio</param>
        /// <param name="dniSocio">
        /// DNI del socio</param>
        /// <param name="puntos">
        /// Puntos del socio</param>
        /// <param name="puntosAFavor">
        /// Partidos a favor del socio</param>
        /// <param name="puntosEnContra">
        /// Partidos en contra del socio</param>
        /// <returns>
        /// Devuelve True si no se produce ningún error, false en caso contrario</returns>
        public bool ActualizarPuntosDeSocio(string nombreEvento, string letraGrupo, string dniSocio, int puntos, int puntosAFavor, int puntosEnContra)
        {
            bool resultado = false;

            try
            {
                sociosDeGrupoTA.ActualizarPuntosDeSocio(nombreEvento, letraGrupo, dniSocio, puntos, puntosAFavor, puntosEnContra);
                resultado = true;
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener el número de eventos que cumplen los filtros especificados por parámetro
        /// </summary>
        /// <param name="nombreEvento">
        /// Cadena que debe contener el nombre del evento</param>
        /// <param name="nombreJuego">
        /// Cadena que debe contener el nombre del juego del evento</param>
        /// <param name="plataformaJuego">
        /// Plataforma del juego del evento ("Todas" = cualquier plataforma)</param>
        /// <param name="fechaInicio">
        /// Fecha desde la que se desean mostrar evento</param>
        /// <param name="fechaFin">
        /// Fecha hasta la que se desean mostrar eventos</param>
        /// <param name="inscripcionesAbiertas">
        /// Valor booleano indicando si se desean mostrar sólo los torneos con inscripciones abiertas</param>
        /// <returns>
        /// Devuelve un valor entero que corresponde al número de eventos que cumplen los filtros</returns>
        public int ObtenerNumeroDeEventosFiltrados(string nombreEvento, string nombreJuego, string plataformaJuego, DateTime fechaInicio, DateTime fechaFin, bool inscripcionesAbiertas)
        {
            int resultado = 0;
            SqlConnection conexion = null;

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                string select = "SELECT COUNT(*) FROM Evento, Torneo ";
                select += "WHERE (Evento.Nombre = Torneo.NombreEvento) AND (NombreEvento LIKE @nombreEvento) AND (NombreJuego LIKE @nombreJuego)";
                if (plataformaJuego != "Todas")
                    select += " AND (PlataformaJuego = @plataformaJuego)";
                select += " AND (FechaInicio BETWEEN @fechaInicio AND @fechaFin) ";
                if (inscripcionesAbiertas)
                    select += "AND (Estado = 'Inscripciones')";

                SqlCommand comandoSql = new SqlCommand(select, conexion);
                comandoSql.Parameters.Add("@nombreEvento", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreEvento"].Value = "%" + nombreEvento + "%";
                comandoSql.Parameters.Add("@nombreJuego", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreJuego"].Value = "%" + nombreJuego + "%";
                comandoSql.Parameters.Add("@plataformaJuego", SqlDbType.VarChar, 20);
                comandoSql.Parameters["@plataformaJuego"].Value = plataformaJuego;
                comandoSql.Parameters.Add("@fechaInicio", SqlDbType.Date);
                comandoSql.Parameters["@fechaInicio"].Value = fechaInicio;
                comandoSql.Parameters.Add("@fechaFin", SqlDbType.Date);
                comandoSql.Parameters["@fechaFin"].Value = fechaFin;
                SqlDataReader dr = comandoSql.ExecuteReader();

                if (dr.Read())
                    resultado = int.Parse(dr[0].ToString());
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los eventos que cumplen los filtros, paginados para mostrarlos en un DataGridView
        /// </summary>
        /// <param name="nombreEvento">
        /// Cadena que debe contener el nombre del evento</param>
        /// <param name="nombreJuego">
        /// Cadena que debe contener el nombre del juego del evento</param>
        /// <param name="plataformaJuego">
        /// Plataforma del juego del evento ("Todas" = cualquier plataforma)</param>
        /// <param name="fechaInicio">
        /// Fecha desde la que se desean mostrar eventos</param>
        /// <param name="fechaFin">
        /// Fecha hasta la que se desean mostrar eventos</param>
        /// <param name="inscripcionesAbiertas">
        /// Indica si se desean mostrar sólo eventos en fase de inscripciones</param>
        /// <param name="desde">
        /// Entero que representa la fila de la Base de Datos desde la que se desean mostrar eventos</param>
        /// <param name="hasta">
        /// Entero que representa la fila de la Base de Datos hasta la que se desean mostrar eventos</param>
        /// <returns>
        /// Devuelve un DataSet con los eventos que cumplen los filtros ya paginados en una tabla llamada "EventosFiltrados"</returns>
        public DataSet ObtenerEventosFiltrados(string nombreEvento, string nombreJuego, string plataformaJuego, DateTime fechaInicio, DateTime fechaFin, bool inscripcionesAbiertas, int desde, int hasta)
        {
            DataSet resultado = new DataSet();
            string select = "";

            try
            {
                select += "SELECT     NombreEvento AS Nombre, NombreJuego AS Juego, PlataformaJuego as Plataforma, FechaInicio as 'F.Inicio', Precio, Notas, Grupos, Estado ";
                select += "FROM         (SELECT     NombreEvento, NombreJuego, PlataformaJuego, FechaInicio, Precio, Notas, Grupos, Estado, ROW_NUMBER() OVER (ORDER BY Nombre ASC) AS ROW ";
                select += "FROM         Evento, Torneo ";
                select += "WHERE (Evento.Nombre = Torneo.NombreEvento) AND (NombreEvento LIKE '%" + nombreEvento + "%') AND (NombreJuego LIKE '%" + nombreJuego + "%')";

                if (plataformaJuego != "Todas")
                    select += " AND (PlataformaJuego = '" + plataformaJuego + "')";
                
                select += " AND (FechaInicio BETWEEN '" + fechaInicio.ToShortDateString() + "' AND '" + fechaFin.ToShortDateString() + "')";

                if (inscripcionesAbiertas)
                    select += " AND (Estado = 'Inscripciones')";
                
                select += ") AS EventosFiltrados ";
                select += "WHERE     (ROW > " + desde.ToString() + ") AND (ROW <= " + hasta.ToString() + ")";

                resultado = ObtenerDatos(select, "EventosFiltrados");
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener la fecha de inicio de un torneo más alta de la Base de Datos
        /// </summary>
        /// <returns>
        /// Devuelve un DateTime con la fecha de inicio de un torneo más alta de la Base de Datos</returns>
        public DateTime ObtenerFechaMaxima()
        {
            DateTime resultado = new DateTime();
            SqlConnection conexion = null;

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                string select = "SELECT TOP (1) FechaInicio FROM Evento, Torneo WHERE (Evento.Nombre = Torneo.NombreEvento) AND FechaInicio IS NOT NULL ORDER BY FechaInicio DESC";
                
                SqlCommand comandoSql = new SqlCommand(select, conexion);
                SqlDataReader dr = comandoSql.ExecuteReader();

                if (dr.Read())
                    resultado = DateTime.Parse(dr[0].ToString());
                else
                    resultado = DateTime.Today;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener la fecha de inicio de un torneo más baja de la Base de Datos
        /// </summary>
        /// <returns>
        /// Devuelve un DateTime con la fecha de inicio de un torneo más baja de la Base de Datos</returns>
        public DateTime ObtenerFechaMinima()
        {
            DateTime resultado = new DateTime();
            SqlConnection conexion = null;

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                string select = "SELECT TOP (1) FechaInicio FROM Evento, Torneo WHERE (Evento.Nombre = Torneo.NombreEvento) AND FechaInicio IS NOT NULL ORDER BY FechaInicio ASC";
                
                SqlCommand comandoSql = new SqlCommand(select, conexion);
                SqlDataReader dr = comandoSql.ExecuteReader();

                if (dr.Read())
                    resultado = DateTime.Parse(dr[0].ToString());
                else
                    resultado = DateTime.Today;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para eliminar un torneo de la Base de Datos
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo que se desea eliminar</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool EliminarTorneo(string nombreTorneo)
        {
            bool resultado = false;

            try
            {
                eventosTA.EliminarTorneo(nombreTorneo);
                resultado = true;
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los datos del torneo especificado por parámetro
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desean obtener los datos</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "DatosTorneo" en la cual se encuentran los datos del torneo</returns>
        public DataSet ObtenerDatosDeTorneo(string nombreTorneo)
        {
            DataSet resultado = new DataSet();

            try
            {
                string select = "SELECT Nombre, NombreJuego, PlataformaJuego, FechaInicio, Grupos, NumeroParticipantes, Precio, Notas, Estado ";
                select += "FROM Evento, Torneo ";
                select += "WHERE (Nombre = NombreEvento) AND (Nombre = '" + nombreTorneo + "')";

                resultado = ObtenerDatos(select, "DatosTorneo");
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los preios de un torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desean obtener los premios</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "PremiosTorneo" en donde se encuentran los preimos del torneo</returns>
        public DataSet ObtenerPremiosDeTorneo(string nombreTorneo)
        {
            DataSet resultado = new DataSet();

            try
            {
                string select = "SELECT NombreEvento, Posicion, Descripcion, DNISocio ";
                select += "FROM Premio ";
                select += "WHERE (NombreEvento = '" + nombreTorneo + "') ";
                select += "ORDER BY Posicion ASC";

                resultado = ObtenerDatos(select, "PremiosTorneo");
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para actualizar en modo desconectado los premios de un torneo
        /// </summary>
        /// <param name="premios">
        /// DataSet en donde se encuentran los premio con los datos modificados que se desean reflejar en la Base de Datos</param>
        /// <param name="nombreTorneo">
        /// Nombre del torneo al cual pertenecen los premios</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool ActualizarPremiosDeTorneo(DataSet premios, string nombreTorneo)
        {
            bool resultado = false;

            try
            {
                string select = "SELECT NombreEvento, Posicion, Descripcion, DNISocio ";
                select += "FROM Premio ";
                select += "WHERE (NombreEvento = '" + nombreTorneo + "') ";
                select += "ORDER BY Posicion ASC";

                resultado = InsertarDatosModificados(premios, select);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para actualizar los datos de un Torneo. Se ejecuta en modo conectado porque debe actualizar datos en más de una tabla
        /// </summary>
        /// <param name="nombre">
        /// Nombre del Torneo</param>
        /// <param name="nombreJuego">
        /// Nombre del juego del Torneo</param>
        /// <param name="plataformaJuego">
        /// Plataforma del juego del Torneo</param>
        /// <param name="numeroParticipantes">
        /// Número de participantes del torneo</param>
        /// <param name="fechaInicio">
        /// Fecha del Torneo</param>
        /// <param name="precio">
        /// Precio de la inscripción del Torneo</param>
        /// <param name="notas">
        /// Notas del torneo</param>
        /// <param name="grupos">
        /// Indica si el torneo posee grupos o no ("Si", "No")</param>
        /// <param name="estado">
        /// Indica el estado del torneo ("Inscripciones", "Grupos", "Eliminatorias", "Finalizado")</param>
        /// <param name="descripcion1">
        /// Descripción del primer premio</param>
        /// <param name="descripcion2">
        /// Descripción del segundo premio</param>
        /// <param name="descripcion3">
        /// Descripción del tercer premio</param>
        /// <param name="descripcion4">
        /// Descripción del cuarto premio</param>
        /// <param name="nombreOriginal">
        /// Nombre del torneo antes de ser modificado</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool ActualizarTorneo(string nombre, string nombreJuego, string plataformaJuego, int numeroParticipantes, DateTime fechaInicio, decimal precio, string notas, string grupos, string estado, string descripcion1, string descripcion2, string descripcion3, string descripcion4, string nombreOriginal)
        {
            bool resultado = false;
            SqlConnection conexion = null;
            SqlTransaction tr = null;
            SqlCommand comandoSql;
            string update = "";

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                tr = conexion.BeginTransaction();

                update = "UPDATE Evento ";
                update += "SET Nombre = @nombre, NombreJuego = @nombreJuego, PlataformaJuego = @plataformaJuego, NumeroParticipantes = @numeroParticipantes, FechaInicio = @fechaInicio, Precio = @precio, Notas = @notas ";
                update += "WHERE (Nombre = '" + nombreOriginal + "')";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Parameters.Add("@nombre", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombre"].Value = nombre;
                comandoSql.Parameters.Add("@nombreJuego", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreJuego"].Value = nombreJuego;
                comandoSql.Parameters.Add("@plataformaJuego", SqlDbType.VarChar, 20);
                comandoSql.Parameters["@plataformaJuego"].Value = plataformaJuego;
                comandoSql.Parameters.Add("@numeroParticipantes", SqlDbType.Int);
                comandoSql.Parameters["@numeroParticipantes"].Value = numeroParticipantes;
                comandoSql.Parameters.Add("@fechaInicio", SqlDbType.Date);
                comandoSql.Parameters["@fechaInicio"].Value = fechaInicio;
                comandoSql.Parameters.Add("@precio", SqlDbType.Decimal);
                comandoSql.Parameters["@precio"].Value = precio;
                comandoSql.Parameters.Add("@notas", SqlDbType.VarChar, 500);
                comandoSql.Parameters["@notas"].Value = notas;
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                update = "UPDATE Torneo ";
                update += "SET NombreEvento = @nombre, Grupos = @grupos, Estado = @estado ";
                update += "WHERE (NombreEvento = '" + nombre + "')";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Parameters.Add("@nombre", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombre"].Value = nombre;
                comandoSql.Parameters.Add("@grupos", SqlDbType.VarChar, 2);
                comandoSql.Parameters["@grupos"].Value = grupos;
                comandoSql.Parameters.Add("@estado", SqlDbType.VarChar, 20);
                comandoSql.Parameters["@estado"].Value = estado;
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                update = "UPDATE Premio ";
                update += "SET Descripcion = @descripcion1 ";
                update += "WHERE (NombreEvento = @nombre) AND (Posicion = 1)";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Parameters.Add("@nombre", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombre"].Value = nombre;
                comandoSql.Parameters.Add("@descripcion1", SqlDbType.VarChar, 200);
                comandoSql.Parameters["@descripcion1"].Value = descripcion1;
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                update = "UPDATE Premio ";
                update += "SET Descripcion = @descripcion2 ";
                update += "WHERE (NombreEvento = @nombre) AND (Posicion = 2)";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Parameters.Add("@nombre", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombre"].Value = nombre;
                comandoSql.Parameters.Add("@descripcion2", SqlDbType.VarChar, 200);
                comandoSql.Parameters["@descripcion2"].Value = descripcion2;
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                update = "UPDATE Premio ";
                update += "SET Descripcion = @descripcion3 ";
                update += "WHERE (NombreEvento = @nombre) AND (Posicion = 3)";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Parameters.Add("@nombre", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombre"].Value = nombre;
                comandoSql.Parameters.Add("@descripcion3", SqlDbType.VarChar, 200);
                comandoSql.Parameters["@descripcion3"].Value = descripcion3;
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                update = "UPDATE Premio ";
                update += "SET Descripcion = @descripcion4 ";
                update += "WHERE (NombreEvento = @nombre) AND (Posicion = 4)";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Parameters.Add("@nombre", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombre"].Value = nombre;
                comandoSql.Parameters.Add("@descripcion4", SqlDbType.VarChar, 200);
                comandoSql.Parameters["@descripcion4"].Value = descripcion4;
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                tr.Commit();
                resultado = true;
            }
            catch (Exception ex)
            {
                tr.Rollback();
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para crear los grupos A y B de un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desean crear los grupos A y B</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool CrearGruposABDeTorneo(string nombreTorneo)
        {
            bool resultado = false;
            SqlConnection conexion = null;
            SqlTransaction tr = null;
            SqlCommand comandoSql;
            string insert = "";

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                tr = conexion.BeginTransaction();

                insert = "INSERT INTO Grupo (NombreEvento, LetraGrupo) ";
                insert += "VALUES (@nombreTorneo, 'A')";

                comandoSql = new SqlCommand(insert, conexion);
                comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                insert = "INSERT INTO Grupo (NombreEvento, LetraGrupo) ";
                insert += "VALUES (@nombreTorneo, 'B')";

                comandoSql = new SqlCommand(insert, conexion);
                comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                tr.Commit();
                resultado = true;
            }
            catch (Exception ex)
            {
                tr.Rollback();
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para crear los grupos C y D de un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo del cual se desean crear los grupos C y D</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool CrearGruposCDDeTorneo(string nombreTorneo)
        {
            bool resultado = false;
            SqlConnection conexion = null;
            SqlTransaction tr = null;
            SqlCommand comandoSql;
            string insert = "";

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                tr = conexion.BeginTransaction();

                insert = "INSERT INTO Grupo (NombreEvento, LetraGrupo) ";
                insert += "VALUES (@nombreTorneo, 'C')";

                comandoSql = new SqlCommand(insert, conexion);
                comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                insert = "INSERT INTO Grupo (NombreEvento, LetraGrupo) ";
                insert += "VALUES (@nombreTorneo, 'D')";

                comandoSql = new SqlCommand(insert, conexion);
                comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                tr.Commit();
                resultado = true;
            }
            catch (Exception ex)
            {
                tr.Rollback();
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para borrar todos los grupos de un torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desean borrar los grupos</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool BorrarGruposDeTorneo(string nombreTorneo)
        {
            bool resultado = false;
            SqlConnection conexion = null;
            SqlCommand comandoSql;
            string delete = "";

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                delete = "DELETE FROM Grupo WHERE (NombreEvento = @nombreTorneo)";

                comandoSql = new SqlCommand(delete, conexion);
                comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                comandoSql.ExecuteNonQuery();

                resultado = true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener el número de socios que cumplen los filtros especificados que NO estén ya inscritos al torneo especificado
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo</param>
        /// <param name="nombreSocio">
        /// Cadena que debe contener el nombre del socio</param>
        /// <param name="apellidos">
        /// Cadeba que debe contener el apellido del socio</param>
        /// <param name="dni">
        /// Cadena que debe contener el DNI del socio</param>
        /// <returns>
        /// Entero que indica el número de socios que cumplen los filtros que NO están ya inscritas al torneo especificado</returns>
        public int ObtenerNumeroDeSociosFiltrados(string nombreTorneo, string nombreSocio, string apellidos, string dni)
        {
            int resultado = 0;
            SqlConnection conexion = null;

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                string select = "SELECT COUNT(*) FROM Socio, Persona WHERE (Socio.DNI = Persona.DNI) ";
                select += "AND (Nombre LIKE @nombreSocio) AND (Apellidos LIKE @apellidos) AND (Socio.DNI LIKE @dni) AND (Socio.DNI NOT IN (SELECT DNISocio FROM SocioInscrito WHERE (NombreEvento = @nombreTorneo)))";

                SqlCommand comandoSql = new SqlCommand(select, conexion);
                comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                comandoSql.Parameters.Add("@nombreSocio", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreSocio"].Value = "%" + nombreSocio + "%";
                comandoSql.Parameters.Add("@apellidos", SqlDbType.VarChar, 100);
                comandoSql.Parameters["@apellidos"].Value = "%" + apellidos + "%";
                comandoSql.Parameters.Add("@dni", SqlDbType.VarChar, 9);
                comandoSql.Parameters["@dni"].Value = "%" + dni + "%";
                SqlDataReader dr = comandoSql.ExecuteReader();

                if (dr.Read())
                {
                    string prueba = dr[0].ToString();
                    resultado = int.Parse(dr[0].ToString());
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los socios que cumplen los filtros que NO estén ya inscritos al torneo, paginados para mostrarlos en un DataGridView
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo</param>
        /// <param name="nombreSocio">
        /// Cadena que debe contener el nombre del socio</param>
        /// <param name="apellidos">
        /// Cadeba que debe contener el apellido del socio</param>
        /// <param name="dni">
        /// Cadena que debe contener el DNI del socio</param>
        /// <param name="desde">
        /// Entero que indica desde que fila de la Base de Datos se desea empezar a coger datos</param>
        /// <param name="hasta">
        /// Entero que indica hasta que fila de la Base de Datos se desean coger socios</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "SociosFiltrados" que contiene los socios que cumplen los filtros que NO esten inscritos ya al torneo</returns>
        public DataSet ObtenerSociosFiltradosPaginados(string nombreTorneo, string nombreSocio, string apellidos, string dni, int desde, int hasta)
        {
            DataSet resultado = new DataSet();
            string select = "";

            try
            {
                select += "SELECT  Nombre, Apellidos, DNI ";
                select += "FROM    (SELECT   Nombre, Apellidos, Socio.DNI, ROW_NUMBER() OVER (ORDER BY Apellidos ASC) AS ROW ";
                select += "         FROM     Socio, Persona ";
                select += "         WHERE    Socio.DNI = Persona.DNI AND (Nombre LIKE '%" + nombreSocio + "%') AND (Apellidos LIKE '%" + apellidos + "%') AND (Socio.DNI LIKE '%" + dni + "%') AND (Socio.DNI NOT IN (SELECT DNISocio FROM SocioInscrito WHERE (NombreEvento = '" + nombreTorneo + "')))) AS SociosFiltrados ";
                select += "WHERE   (ROW > " + desde.ToString() + ") AND (ROW <= " + hasta.ToString() + ")";

                resultado = ObtenerDatos(select, "SociosFiltrados");
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener el número de socios inscritos aun Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo</param>
        /// <returns>
        /// Entero que contiene el número de socios inscritos al Torneo especificado</returns>
        public int ObtenerNumeroDeSociosInscritos(string nombreTorneo)
        {
            int resultado = 0;
            SqlConnection conexion = null;

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                string select = "SELECT COUNT(*) ";
                select += "FROM SocioInscrito, Persona ";
                select += "WHERE (NombreEvento = @nombreTorneo) AND (DNISocio = DNI)";

                SqlCommand comandoSql = new SqlCommand(select, conexion);
                comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                SqlDataReader dr = comandoSql.ExecuteReader();

                if (dr.Read())
                    resultado = int.Parse(dr[0].ToString());
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los socios inscritos a un Torneo paginados para mostrarlos en un DataGridView
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desean obtener los socios paginados</param>
        /// <param name="desde">
        /// Entero que representa el valor de la fila de la Base de Datos desde la cual se desean empezar a obtener los sociso</param>
        /// <param name="hasta">
        /// Entero que representa el valor de la fila de la Base de Datos hasta la cual se desean obtener los socios</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "SociosInscritos" que contiene los socios inscritos al Torneo paginados</returns>
        public DataSet ObtenerSociosInscritosPaginados(string nombreTorneo, int desde, int hasta)
        {
            DataSet resultado = new DataSet();

            try
            {
                string select = "SELECT Nombre, Apellidos, DNI ";
                select += "FROM (SELECT Persona.Nombre, Persona.Apellidos, Persona.DNI, ROW_NUMBER() OVER (ORDER BY Apellidos ASC) AS ROW ";
                select += "     FROM SocioInscrito, Persona ";
                select += "     WHERE (NombreEvento = '" + nombreTorneo + "') AND (DNISocio = DNI)) AS SociosInscritosFiltrados ";
                select += "WHERE (ROW > " + desde.ToString() + ") AND (ROW <= " + hasta.ToString() + ")";

                resultado = ObtenerDatos(select, "SociosInscritos");
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener todos los socios inscritos a un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo del cual se desean obtener los socios inscritos</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "SociosInscritos" que contiene los datos de todos los socios inscritos al Torneo</returns>
        public DataSet ObtenerTodosLosSociosInscritosATorneo(string nombreTorneo)
        {
            DataSet resultado = new DataSet();

            try
            {
                string select = "SELECT Nombre, Apellidos, DNI ";
                select += "      FROM   SocioInscrito, Persona ";
                select += "      WHERE (NombreEvento = '" + nombreTorneo + "') AND (DNISocio = DNI)";

                resultado = ObtenerDatos(select, "SociosInscritos");
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener los socios clasificados de un Torneo.
        /// Esto corresponde a los 4 socios con mejor puntuación de cada grupo del torneo.
        /// En caso de producirse un empate a puntos, el mejor es el que más victorias tenga a su favor.
        /// En caso de empate de victorias, se obtiene el socio con menos derrotas.
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desean obtener los socios clasificados</param>
        /// <returns>
        /// Devuelve un DataSet con una tabla llamada "SociosClasificados" en donde están los DNIs de los socios clasificados del Torneo</returns>
        public DataSet ObtenerSociosClasificadosDeTorneo(string nombreTorneo)
        {
            DataSet resultado = new DataSet();
            string select = "";

            try
            {
                
                select = "SELECT  DNISocio ";
                select += "FROM   SocioDeGrupo ";
                select += "WHERE (DNISocio IN ";
                select += "           (SELECT TOP (4) DNISocio ";
                select += "            FROM   SocioDeGrupo ";
                select += "            WHERE      (NombreEvento = '" + nombreTorneo + "') AND (LetraGrupo = 'A') ";
                select += "            ORDER BY Puntos DESC, PuntosAFavor DESC, PuntosEnContra ASC) OR ";
                select += "      DNISocio IN" ;
                select += "          (SELECT     TOP (4) DNISocio" ;
                select += "            FROM          SocioDeGrupo ";
                select += "            WHERE      (NombreEvento = '" + nombreTorneo + "') AND (LetraGrupo = 'B')";
                select += "            ORDER BY Puntos DESC, PuntosAFavor DESC, PuntosEnContra ASC) OR" ;
                select += "      DNISocio IN" ;
                select += "          (SELECT     TOP (4) DNISocio" ;
                select += "            FROM          SocioDeGrupo " ;
                select += "            WHERE      (NombreEvento = '" + nombreTorneo + "') AND (LetraGrupo = 'C')";
                select += "            ORDER BY Puntos DESC, PuntosAFavor DESC, PuntosEnContra ASC) OR ";
                select += "      DNISocio IN ";
                select += "          (SELECT     TOP (4) DNISocio" ;
                select += "            FROM          SocioDeGrupo " ;
                select += "            WHERE      (NombreEvento = '" + nombreTorneo + "') AND (LetraGrupo = 'D') ";
                select += "            ORDER BY Puntos DESC, PuntosAFavor DESC, PuntosEnContra ASC)) ";
                select += "AND (NombreEvento = '" + nombreTorneo + "')";

                resultado = ObtenerDatos(select, "SociosClasificados");
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return resultado;
        }

        /// <summary>
        /// Función para inscribir un socio a un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo al que se desea inscribir al socio</param>
        /// <param name="dniSocio">
        /// DNI del socio al cual se desea inscribir al Torneo</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool InscribirSocioATorneo(string nombreTorneo, string dniSocio)
        {
            bool resultado = false;
            SqlConnection conexion = null;
            SqlCommand comandoSql;
            string insert = "";

            try
            {
                if (!ExisteSocioInscritoEnTorneo(nombreTorneo, dniSocio))
                {
                    conexion = new SqlConnection(cadConexion);
                    conexion.Open();

                    insert = "INSERT INTO SocioInscrito (NombreEvento, DNISocio) ";
                    insert += "VALUES (@nombreTorneo, @dniSocio)";

                    comandoSql = new SqlCommand(insert, conexion);
                    comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                    comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                    comandoSql.Parameters.Add("@dniSocio", SqlDbType.VarChar, 9);
                    comandoSql.Parameters["@dniSocio"].Value = dniSocio;
                    comandoSql.ExecuteNonQuery();

                    resultado = true;
                }
                else
                {
                    resultado = false;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para borrar la suscripción de un socio a un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo del cual se desea eliminar la suscripción del socio</param>
        /// <param name="dniSocio">
        /// DNI del socio del cual se desea eliminar la suscripción</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool BorrarSuscripcionDeSocioATorneo(string nombreTorneo, string dniSocio)
        {
            bool resultado = false;
            SqlConnection conexion = null;
            SqlCommand comandoSql;
            string delete = "";

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                delete = "DELETE FROM SocioInscrito WHERE (NombreEvento = @nombreTorneo) AND (DNISocio = @dniSocio)";

                comandoSql = new SqlCommand(delete, conexion);
                comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                comandoSql.Parameters.Add("@dniSocio", SqlDbType.VarChar, 9);
                comandoSql.Parameters["@dniSocio"].Value = dniSocio;
                comandoSql.ExecuteNonQuery();

                resultado = true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para comprobar si un socio esta inscrito a un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desea comprobar si el socio está ya inscrito</param>
        /// <param name="dniSocio">
        /// DNI del socio que se desea comprobar si está suscrito al torneo</param>
        /// <returns>
        /// Devuelve True si el socio especificado esta inscrito al Torneo especificado, False en caso contrario</returns>
        public bool ExisteSocioInscritoEnTorneo(string nombreTorneo, string dniSocio)
        {
            bool resultado = false;
            SqlConnection conexion = null;

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                string select = "SELECT NombreEvento, DNISocio ";
                select += "FROM SocioInscrito ";
                select += "WHERE (NombreEvento = @nombreTorneo) AND (DNISocio = @dniSocio)";

                SqlCommand comandoSql = new SqlCommand(select, conexion);
                comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                comandoSql.Parameters.Add("@dniSocio", SqlDbType.VarChar, 9);
                comandoSql.Parameters["@dniSocio"].Value = dniSocio;
                SqlDataReader dr = comandoSql.ExecuteReader();

                if (dr.Read())
                    resultado = true;
                else
                    resultado = false;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para obtener el número de participantes que deben inscribirse a un Torneo
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desea obtener el número de participantes que deben inscribirse</param>
        /// <returns>
        /// Entero que contiene el número de participantes que deben inscribirse al torneo</returns>
        public int ObtenerNumeroDeParticipantesDeTorneo(string nombreTorneo)
        {
            int resultado = 0;
            SqlConnection conexion = null;

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                string select = "SELECT NumeroParticipantes ";
                select += "FROM Evento ";
                select += "WHERE (Nombre = @nombreTorneo)";

                SqlCommand comandoSql = new SqlCommand(select, conexion);
                comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                SqlDataReader dr = comandoSql.ExecuteReader();

                if (dr.Read())
                    resultado = int.Parse(dr[0].ToString());
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para cerrar la fase de inscripciones de un Torneo. En el Torneo deben de estar inscritos previamente el número de participantes correspondiente.
        /// La función repartirá aleatoriamente los socios inscritos en los grupos correspondientes, si el torneo tiene fase de grupos, o en las eliminatorias si es el caso.
        /// En caso de que se deba pasar a una fase de grupos también se crearán todos los partidos de los grupos en esta fase, en donde se determina los contrincantes en cada jornada.
        /// El estado del torneo pasa a "Grupos" ó "Eliminatorias" según sea necesario.
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo que se desea cerrar las inscripciones</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool CerrarInscripcionesDeTorneo(string nombreTorneo)
        {
            bool resultado = false;
            SqlConnection conexion = null;
            SqlTransaction tr = null;
            SqlCommand comandoSql;
            string insert = "";
            string update = "";

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                tr = conexion.BeginTransaction();

                DataSet dsTorneo = ObtenerDatosDeTorneo(nombreTorneo);
                DataSet dsSociosInscritos = ObtenerTodosLosSociosInscritosATorneo(nombreTorneo);
                Random random = new Random();
                string socioA = "";
                string socioB = "";
                int numeroAleatorio = 0;
                int numeroDeParticipantes = ObtenerNumeroDeParticipantesDeTorneo(nombreTorneo);
                int i = 0;

                if ((string)dsTorneo.Tables[0].Rows[0]["Grupos"] == "No") // Eliminatorias
                {
                    for (i = 1; i <= (numeroDeParticipantes / 2); i++)
                    {
                        numeroAleatorio = random.Next(0, dsSociosInscritos.Tables[0].Rows.Count - 1);
                        socioA = (string)dsSociosInscritos.Tables[0].Rows[numeroAleatorio]["DNI"];
                        dsSociosInscritos.Tables[0].Rows.RemoveAt(numeroAleatorio);

                        numeroAleatorio = random.Next(0, dsSociosInscritos.Tables[0].Rows.Count - 1);
                        socioB = (string)dsSociosInscritos.Tables[0].Rows[numeroAleatorio]["DNI"];
                        dsSociosInscritos.Tables[0].Rows.RemoveAt(numeroAleatorio);

                        insert = "INSERT INTO PartidoPlayOff (NombreEvento, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES (@nombreTorneo, @partido, @socioA, @socioB)";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                        comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                        comandoSql.Parameters.Add("@partido", SqlDbType.Int);
                        comandoSql.Parameters["@partido"].Value = i;
                        comandoSql.Parameters.Add("@socioA", SqlDbType.VarChar, 9);
                        comandoSql.Parameters["@socioA"].Value = socioA;
                        comandoSql.Parameters.Add("@socioB", SqlDbType.VarChar, 9);
                        comandoSql.Parameters["@socioB"].Value = socioB;
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();
                    }

                    for (i = i; i <= (numeroDeParticipantes + 1); i++)
                    {
                        insert = "INSERT INTO PartidoPlayOff (NombreEvento, Partido) ";
                        insert += "VALUES (@nombreTorneo, @partido)";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                        comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                        comandoSql.Parameters.Add("@partido", SqlDbType.Int);
                        comandoSql.Parameters["@partido"].Value = i;
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();
                    }

                    update = "UPDATE Torneo ";
                    update += "SET Estado = 'Eliminatorias' ";
                    update += "WHERE (NombreEvento = '" + nombreTorneo + "')";

                    comandoSql = new SqlCommand(update, conexion);
                    comandoSql.Transaction = tr;
                    comandoSql.ExecuteNonQuery();
                }
                else // Grupos
                {
                    for (i = 0; i < ((int)dsTorneo.Tables[0].Rows[0]["NumeroParticipantes"] / 6); i++)
                    {
                        ArrayList sociosDeGrupo = new ArrayList();
                        string letra = "";

                        switch (i)
                        {
                            case 0:
                                letra = "A";
                                break;
                            case 1:
                                letra = "B";
                                break;
                            case 2:
                                letra = "C";
                                break;
                            case 3:
                                letra = "D";
                                break;
                        }

                        for (int j = 0; j < 6; j++)
                        {
                            numeroAleatorio = random.Next(0, dsSociosInscritos.Tables[0].Rows.Count - 1);
                            socioA = (string)dsSociosInscritos.Tables[0].Rows[numeroAleatorio]["DNI"];
                            dsSociosInscritos.Tables[0].Rows.RemoveAt(numeroAleatorio);

                            insert = "INSERT INTO SocioDeGrupo (NombreEvento, LetraGrupo, DNISocio) ";
                            insert += "VALUES (@nombreTorneo, @letra, @socioA)";

                            comandoSql = new SqlCommand(insert, conexion);
                            comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                            comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                            comandoSql.Parameters.Add("@letra", SqlDbType.VarChar, 1);
                            comandoSql.Parameters["@letra"].Value = letra;
                            comandoSql.Parameters.Add("@socioA", SqlDbType.VarChar, 9);
                            comandoSql.Parameters["@socioA"].Value = socioA;
                            comandoSql.Transaction = tr;
                            comandoSql.ExecuteNonQuery();

                            sociosDeGrupo.Add(socioA);
                        }

                        string dniSocio1 = (string)sociosDeGrupo[0];
                        string dniSocio2 = (string)sociosDeGrupo[1];
                        string dniSocio3 = (string)sociosDeGrupo[2];
                        string dniSocio4 = (string)sociosDeGrupo[3];
                        string dniSocio5 = (string)sociosDeGrupo[4];
                        string dniSocio6 = (string)sociosDeGrupo[5];

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 1, '" + dniSocio1 + "', '" + dniSocio2 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 2, '" + dniSocio3 + "', '" + dniSocio6 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 3, '" + dniSocio4 + "', '" + dniSocio5 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 4, '" + dniSocio1 + "', '" + dniSocio3 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 5, '" + dniSocio2 + "', '" + dniSocio4 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 6, '" + dniSocio5 + "', '" + dniSocio6 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 7, '" + dniSocio1 + "', '" + dniSocio4 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 8, '" + dniSocio2 + "', '" + dniSocio6 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 9, '" + dniSocio3 + "', '" + dniSocio5 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 10, '" + dniSocio1 + "', '" + dniSocio5 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 11, '" + dniSocio2 + "', '" + dniSocio3 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 12, '" + dniSocio4 + "', '" + dniSocio6 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 13, '" + dniSocio1 + "', '" + dniSocio6 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 14, '" + dniSocio2 + "', '" + dniSocio5 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO PartidoGrupo (NombreEvento, LetraGrupo, Partido, DNISocioA, DNISocioB) ";
                        insert += "VALUES ('" + nombreTorneo + "', '" + letra + "', 15, '" + dniSocio3 + "', '" + dniSocio4 + "')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();
                    }

                    update = "UPDATE Torneo ";
                    update += "SET Estado = 'Grupos' ";
                    update += "WHERE (NombreEvento = '" + nombreTorneo + "')";

                    comandoSql = new SqlCommand(update, conexion);
                    comandoSql.Transaction = tr;
                    comandoSql.ExecuteNonQuery();
                }

                tr.Commit();
                resultado = true;
            }
            catch (Exception ex)
            {
                tr.Rollback();
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para comprobar si todos los partidos de los grupos de un torneo tienen puntuación asignada.
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del torneo del cual se desea comprobar que todos los partidos de todos los grupos tienen puntuación</param>
        /// <returns>
        /// Devuelve True en caso de que todos los partidos tienen puntuación asignada, False en caso contrario</returns>
        public bool TodosLosPartidosConPuntuacion(string nombreTorneo)
        {
            bool resultado = true;
            SqlConnection conexion = null;

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                string select = "SELECT TOP (1) NombreEvento ";
                select += "FROM PartidoGrupo ";
                select += "WHERE (NombreEvento = @nombreTorneo) AND (PuntosA IS NULL OR PuntosB IS NULL)";

                SqlCommand comandoSql = new SqlCommand(select, conexion);
                comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                SqlDataReader dr = comandoSql.ExecuteReader();

                if (dr.Read())
                    resultado = false;
                else
                    resultado = true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para cerrar las jornadas de un Torneo y pasar a la fase de Eliminatorias.
        /// Las jornadas deben de estar preparadas para cerrarse. Todos los partidos deben de tener puntuación.
        /// La función obtendrá los socios clasificados y los repartirá aleatoriamente en los partidos de eliminatorias.
        /// El estado del Torneo pasa a "Eliminatorias"
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo del cual se desean cerrar las jornadas</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool CerrarJornadasDeTorneo(string nombreTorneo)
        {
            bool resultado = false;
            SqlConnection conexion = null;
            SqlTransaction tr = null;
            SqlCommand comandoSql;
            string insert = "";
            string update = "";

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                tr = conexion.BeginTransaction();

                DataSet dsSociosClasificados = ObtenerSociosClasificadosDeTorneo(nombreTorneo);
                Random random = new Random();
                string socioA = "";
                string socioB = "";
                int numeroAleatorio = 0;
                int numeroDeParticipantes = 0;

                if (ObtenerNumeroDeParticipantesDeTorneo(nombreTorneo) == 12)
                    numeroDeParticipantes = 8;
                else
                    numeroDeParticipantes = 16;

                int i = 0;

                for (i = 1; i <= (numeroDeParticipantes / 2); i++)
                {
                    numeroAleatorio = random.Next(0, dsSociosClasificados.Tables[0].Rows.Count - 1);
                    socioA = (string)dsSociosClasificados.Tables[0].Rows[numeroAleatorio]["DNISocio"];
                    dsSociosClasificados.Tables[0].Rows.RemoveAt(numeroAleatorio);

                    numeroAleatorio = random.Next(0, dsSociosClasificados.Tables[0].Rows.Count - 1);
                    socioB = (string)dsSociosClasificados.Tables[0].Rows[numeroAleatorio]["DNISocio"];
                    dsSociosClasificados.Tables[0].Rows.RemoveAt(numeroAleatorio);

                    insert = "INSERT INTO PartidoPlayOff (NombreEvento, Partido, DNISocioA, DNISocioB) ";
                    insert += "VALUES (@nombreTorneo, @partido, @socioA, @socioB)";

                    comandoSql = new SqlCommand(insert, conexion);
                    comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                    comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                    comandoSql.Parameters.Add("@partido", SqlDbType.Int);
                    comandoSql.Parameters["@partido"].Value = i;
                    comandoSql.Parameters.Add("@socioA", SqlDbType.VarChar, 9);
                    comandoSql.Parameters["@socioA"].Value = socioA;
                    comandoSql.Parameters.Add("@socioB", SqlDbType.VarChar, 9);
                    comandoSql.Parameters["@socioB"].Value = socioB;
                    comandoSql.Transaction = tr;
                    comandoSql.ExecuteNonQuery();
                }

                for (i = i; i <= (numeroDeParticipantes + 1); i++)
                {
                    insert = "INSERT INTO PartidoPlayOff (NombreEvento, Partido) ";
                    insert += "VALUES (@nombreTorneo, @partido)";

                    comandoSql = new SqlCommand(insert, conexion);
                    comandoSql.Parameters.Add("@nombreTorneo", SqlDbType.VarChar, 50);
                    comandoSql.Parameters["@nombreTorneo"].Value = nombreTorneo;
                    comandoSql.Parameters.Add("@partido", SqlDbType.Int);
                    comandoSql.Parameters["@partido"].Value = i;
                    comandoSql.Transaction = tr;
                    comandoSql.ExecuteNonQuery();
                }

                update = "UPDATE Torneo ";
                update += "SET Estado = 'Eliminatorias' ";
                update += "WHERE (NombreEvento = '" + nombreTorneo + "')";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                tr.Commit();
                resultado = true;
            }
            catch (Exception ex)
            {
                tr.Rollback();
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Función para cerrar la fase de eliminatorias de un torneo, y así Finalizar el Torneo.
        /// Todos los partidos de la fase de eliminatorias deben de tener puntuación previamente
        /// El estado del torneo pasa a ser "Finalizado"
        /// </summary>
        /// <param name="nombreTorneo">
        /// Nombre del Torneo que se desean cerrar la fase de eliminatorias.</param>
        /// <returns>
        /// Devuelve True si no ha ocurrido ningún error, False en caso contrario</returns>
        public bool CerrarEliminatoriasDeTorneo(string nombreTorneo)
        {
            bool resultado = false;
            SqlConnection conexion = null;
            SqlTransaction tr = null;
            SqlCommand comandoSql;
            string update = "";

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                DataSet dsPartidos = cadPartido.ObtenerPartidos(nombreTorneo);
                int numeroDeParticipantes = ObtenerNumeroDeParticipantesDeTorneo(nombreTorneo);

                if (numeroDeParticipantes == 8 || numeroDeParticipantes == 12)
                    numeroDeParticipantes = 8;
                else
                    numeroDeParticipantes = 16;

                tr = conexion.BeginTransaction();

                update = "UPDATE Premio ";
                update += "SET DNISocio = '";
                if ((int)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 2][4] > (int)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 2][5])
                    update += (string)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 2][2];
                else
                    update += (string)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 2][3];
                update += "' ";
                update += "WHERE (NombreEvento = '" + nombreTorneo + "') AND (Posicion = 1)";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                update = "UPDATE Premio ";
                update += "SET DNISocio = '";
                if ((int)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 2][4] > (int)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 2][5])
                    update += (string)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 2][3];
                else
                    update += (string)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 2][2];
                update += "' ";
                update += "WHERE (NombreEvento = '" + nombreTorneo + "') AND (Posicion = 2)";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                update = "UPDATE Premio ";
                update += "SET DNISocio = '";
                if ((int)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 1][4] > (int)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 1][5])
                    update += (string)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 1][2];
                else
                    update += (string)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 1][3];
                update += "' ";
                update += "WHERE (NombreEvento = '" + nombreTorneo + "') AND (Posicion = 3)";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                update = "UPDATE Premio ";
                update += "SET DNISocio = '";
                if ((int)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 1][4] > (int)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 1][5])
                    update += (string)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 1][3];
                else
                    update += (string)dsPartidos.Tables[0].Rows[numeroDeParticipantes - 1][2];
                update += "' ";
                update += "WHERE (NombreEvento = '" + nombreTorneo + "') AND (Posicion = 4)";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();


                /********************** FINAL **********************/
                update = "UPDATE Torneo ";
                update += "SET Estado = 'Finalizado' ";
                update += "WHERE (NombreEvento = '" + nombreTorneo + "')";

                comandoSql = new SqlCommand(update, conexion);
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                tr.Commit();
                resultado = true;
            }
            catch (Exception ex)
            {
                tr.Rollback();
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }

        /************************************************** Fin Funciones de Marcos **************************************************/

        /************************************************** Funciones de Mirellys ****************************************************/
        /// <summary>
        /// Función para dar de alta un torneo.  Esta función inserta el evento, el torneo, los grupos y premios.
        /// </summary>
        /// <param name="nombre">nombre el evento</param>
        /// <param name="nombreJuego">juego que tiene asignado</param>
        /// <param name="nombrePlataforma">plataforma del juego</param>
        /// <param name="numeroParticipantes">cantidad de participantes, si es eliminatorias solo podran ser 8 o 16, si es grupos 12 o 24</param>
        /// <param name="fechaInicio">fecha de inicio del torneo</param>
        /// <param name="precio">valor que tendra</param>
        /// <param name="notas">notas opcionales</param>
        /// <param name="grupos">valor si/no para indicar si el torneo tiene o no grupos</param>
        /// <param name="estado">los estados pueden ser en inscripciones, grupos, eliminatorias o finalizacion</param>
        /// <param name="posicion1">valor 1</param>
        /// <param name="descripcion1">descripcion del premio de la posicion 1</param>
        /// <param name="posicion2">valor 2</param>
        /// <param name="descripcion2">descripcion del premio de la posicion 2</param>
        /// <param name="posicion3">valor 3</param>
        /// <param name="descripcion3">descripcion del premio de la posicion 3</param>
        /// <param name="posicion4">valor 4</param>
        /// <param name="descripcion4">descripcion del premio de la posicion 4</param>
        /// <returns>Devuelve un valor booleano verdadero en caso de haber hecho la inserción correctamente</returns>
        public bool AltaTorneo(string nombre, string nombreJuego, string nombrePlataforma, int numeroParticipantes, DateTime fechaInicio, decimal precio, string notas, string grupos, string estado, int posicion1, string descripcion1, int posicion2, string descripcion2, int posicion3, string descripcion3, int posicion4, string descripcion4)
        {
            bool resultado = false;

            SqlConnection conexion = null;
            SqlTransaction tr = null;
            SqlCommand comandoSql = null;
            string insert = "";

            try
            {
                conexion = new SqlConnection(cadConexion);
                conexion.Open();
                tr = conexion.BeginTransaction();

                /*________________________ Insert en el Evento _____________________*/
                insert = "INSERT INTO EVENTO (Nombre, NombreJuego,PlataformaJuego,NumeroParticipantes,FechaInicio,Precio,Notas) ";
                insert += "VALUES ('"+nombre+"', '"+nombreJuego+"', '"+nombrePlataforma+"', "+numeroParticipantes+", '"+fechaInicio.ToShortDateString()+"', @precio, '"+notas+"')";

                comandoSql = new SqlCommand(insert, conexion);
                comandoSql.Parameters.Add("@precio", SqlDbType.Decimal);
                comandoSql.Parameters["@precio"].Value = precio;
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                /*________________________ Insert en el Torneo _____________________*/

                insert = "INSERT INTO TORNEO (NombreEvento, Grupos, Estado) ";
                insert += "VALUES ('" + nombre + "', '" + grupos + "', '" + estado + "')";

                comandoSql = new SqlCommand(insert, conexion);
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                /*________________________ Insert 2 o 4 grupos _____________________*/
                if (grupos == "Si")
                {
                    insert = "INSERT INTO GRUPO (NombreEvento, LetraGrupo) ";
                    insert += "VALUES ('" + nombre + "', 'A')";

                    comandoSql = new SqlCommand(insert, conexion);
                    comandoSql.Transaction = tr;
                    comandoSql.ExecuteNonQuery();

                    insert = "INSERT INTO GRUPO (NombreEvento, LetraGrupo) ";
                    insert += "VALUES ('" + nombre + "', 'B')";

                    comandoSql = new SqlCommand(insert, conexion);
                    comandoSql.Transaction = tr;
                    comandoSql.ExecuteNonQuery();

                    if (numeroParticipantes == 24)
                    {
                        insert = "INSERT INTO GRUPO (NombreEvento, LetraGrupo) ";
                        insert += "VALUES ('" + nombre + "', 'C')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();

                        insert = "INSERT INTO GRUPO (NombreEvento, LetraGrupo) ";
                        insert += "VALUES ('" + nombre + "', 'D')";

                        comandoSql = new SqlCommand(insert, conexion);
                        comandoSql.Transaction = tr;
                        comandoSql.ExecuteNonQuery();
                    }
                }

                /*________________________ Insert 4 Premios _____________________*/

                insert = "INSERT INTO PREMIO (NombreEvento, Posicion, Descripcion, DNISocio) ";
                insert += "VALUES ('" + nombre + "', " + posicion1 + ", '" + descripcion1 + "', NULL)";

                comandoSql = new SqlCommand(insert, conexion);
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                insert = "INSERT INTO PREMIO (NombreEvento, Posicion, Descripcion, DNISocio) ";
                insert += "VALUES ('" + nombre + "', " + posicion2 + ", '" + descripcion2 + "', NULL)";

                comandoSql = new SqlCommand(insert, conexion);
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                insert = "INSERT INTO PREMIO (NombreEvento, Posicion, Descripcion, DNISocio) ";
                insert += "VALUES ('" + nombre + "', " + posicion3 + ", '" + descripcion3 + "', NULL)";

                comandoSql = new SqlCommand(insert, conexion);
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                insert = "INSERT INTO PREMIO (NombreEvento, Posicion, Descripcion, DNISocio) ";
                insert += "VALUES ('" + nombre + "', " + posicion4 + ", '" + descripcion4 + "', NULL)";

                comandoSql = new SqlCommand(insert, conexion);
                comandoSql.Transaction = tr;
                comandoSql.ExecuteNonQuery();

                tr.Commit();
                resultado = true;
            }
            catch (Exception ex)
            {
                tr.Rollback();
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }

            return resultado;
        }
        
        /// <summary>
        /// función que permite saber si existe un determinado torneo para verificarlo antes de crear uno nuevo
        /// </summary>
        /// <param name="nombre">recibe como parametro el nombre del torneo a veficar</param>
        /// <returns>Devuelve un valor booleano indicado true si el torneo existe en el sistema</returns>
        public bool ExisteTorneo(string nombre)
        {
            bool resultado = false;
            SqlConnection conexion = null;

            try
            {
                string select = "SELECT Nombre FROM Evento WHERE (Nombre ='" + nombre + "')";
                conexion = new SqlConnection(cadConexion);
                conexion.Open();

                SqlCommand comandoSql = new SqlCommand(select, conexion);
                SqlDataReader dr = comandoSql.ExecuteReader();

                if (dr.Read())
                    resultado = true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conexion != null)
                    conexion.Close();
            }
            return resultado;
        }
        /************************************************** Fin Funciones de Mirellys ************************************************/
    }
}
